{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# C++的函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. 函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1 函数概述"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "① 函数作用：将一段经常使用的代码封装起来，减少重复代码。\n",
    "\n",
    "② 一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2 函数定义"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "① 函数的定义主要有5个部分：\n",
    "\n",
    "1. 返回值类型：一个函数可以返回一个值。\n",
    "2. 函数名：给函数起个名称。\n",
    "3. 参数列表：使用该函数时，传入的数据。\n",
    "4. 函数体语句：花括号内的代码，函数内需要执行的语句。\n",
    "5. return表达式：和返回值类型挂钩，函数执行完后，返回相应的数据。\n",
    "\n",
    "② 语法格式如下所示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "返回值类型 函数名 (参数列表)\n",
    "{\n",
    "     函数体语句\n",
    "\n",
    "     return 表达式\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <iostream>\n",
    "using namespace std;\n",
    "\n",
    "//函数的定义\n",
    "//语法：返回值类型 函数名 (参数列表) { 函数体语句 return表达式 }\n",
    "\n",
    "//加法函数，实现两个整型相加，并且将相加的结果进行返回\n",
    "int add(int num1, int num2)\n",
    "{\n",
    "    int sum = num1 + num2;\n",
    "    return sum;\n",
    "}\n",
    "\n",
    "int main()\n",
    "{\n",
    "\n",
    "    system(\"pause\");   //按任意键继续\n",
    "\n",
    "    return 0;\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3 函数调用"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "① 功能：使用定义好的函数\n",
    "\n",
    "② 语法：函数名(参数)\n",
    "\n",
    "③ 函数定义里小括号内称为形参，函数调用时传入的参数称为实参"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <iostream>\n",
    "using namespace std;\n",
    "\n",
    "//函数的定义\n",
    "//语法:\n",
    "//返回值类型 函数名 (参数列表) { 函数体语句 return表达式 }\n",
    "\n",
    "//定义加法函数\n",
    "//函数定义的时候，num1和num2并不是真实数据\n",
    "//它们只是一个形式上的参数，简称形参\n",
    "int add(int num1, int num2)\n",
    "{\n",
    "    int sum = num1 + num2;\n",
    "    return sum;\n",
    "}\n",
    "\n",
    "int main()\n",
    "{\n",
    "    //main函数中调用add函数\n",
    "    int a = 10;\n",
    "    int b = 20;\n",
    "\n",
    "    //函数调用语法：函数名称：（参数）\n",
    "    //a和b称为 实际参数，简称实参\n",
    "    //当调用函数的时候，实参的值会传递给形参\n",
    "    int c = add(a, b);\n",
    "\n",
    "    cout << \"c = \" << c << endl;\n",
    "\n",
    "    system(\"pause\");   //按任意键继续\n",
    "\n",
    "    return 0;\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "运行结果：\n",
    " - c = 30\n",
    " - 请按任意键继续. . ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.4 函数值传递"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "① 所谓值传递，就是函数调用时实参将数值传入给形参。\n",
    "\n",
    "② 值传递时，如果形参发生改变，并不影响实参。\n",
    "\n",
    "③ 在下面代码例子中，实参传进去时，新参会产生新的内存空间赋值，对num1、num2的操作并不会改变实参a、b的值。"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <iostream>\n",
    "using namespace std;\n",
    "\n",
    "//值传递\n",
    "//定义函数，实现两个数字进行交换函数\n",
    "\n",
    "//如果函数不需要返回值，声明的时候可以写void\n",
    "void swap(int num1, int num2)\n",
    "{\n",
    "    cout << \"交换前：\" << endl;\n",
    "    cout << \"num1= \" << num1 << endl;\n",
    "    cout << \"num2= \" << num2 << endl;\n",
    "\n",
    "    int temp = num1;\n",
    "    num1 = num2;\n",
    "    num2 = temp;\n",
    "\n",
    "    cout << \"交换后：\" << endl;\n",
    "    cout << \"num1= \" << num1 << endl;\n",
    "    cout << \"num2= \" << num2 << endl;\n",
    "\n",
    "    return;  //前面写了void，所以不需要返回值。返回值不需要的时候，也可以不写return。\n",
    "}\n",
    "\n",
    "\n",
    "int main()\n",
    "{\n",
    "    //main函数中调用add函数\n",
    "    int a = 10;\n",
    "    int b = 20;\n",
    "\n",
    "    cout << \"a = \" << a << endl;\n",
    "    cout << \"b = \" << b << endl;\n",
    "\n",
    "    //当我们把值传递的时候，函数的形参发生发生改变，并不会影响实参\n",
    "    swap(a, b);\n",
    "    cout << \"a = \" << a << endl;\n",
    "    cout << \"b = \" << b << endl;\n",
    "\n",
    "    system(\"pause\");   //按任意键继续\n",
    "\n",
    "    return 0;\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "运行结果：  \n",
    " - a = 10  \n",
    " - b = 20  \n",
    " - 交换前：  \n",
    " - num1= 10  \n",
    " - num2= 20  \n",
    " - 交换后：  \n",
    " - num1= 20  \n",
    " - num2= 10  \n",
    " - a = 10  \n",
    " - b = 20"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.5 函数常见样式"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "① 常见的函数样式有四种\n",
    "\n",
    "1. 无参无返\n",
    "2. 有参无返\n",
    "3. 无参有返\n",
    "4. 有参有返"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <iostream>\n",
    "using namespace std;\n",
    "\n",
    "//函数常见样式\n",
    "//1、无参无返\n",
    "void test01()\n",
    "{\n",
    "    cout << \"this is test01\" << endl;\n",
    "}\n",
    "\n",
    "//2、有参无返\n",
    "void test02(int a)\n",
    "{\n",
    "    cout << \"this is test 02 a = \" << a << endl;\n",
    "}\n",
    "\n",
    "//3、无参有返\n",
    "int test03()\n",
    "{\n",
    "    cout << \"this is test 03 \" << endl;\n",
    "\n",
    "    return 1000;\n",
    "}\n",
    "\n",
    "//4、有参有返\n",
    "int test04(int a )\n",
    "{\n",
    "    cout << \"this is test 04 a = \" << a << endl;\n",
    "\n",
    "    return a;\n",
    "}\n",
    "\n",
    "int main()\n",
    "{\n",
    "    //无参无返函数调用\n",
    "    test01();\n",
    "\n",
    "    //有参无返函数调用\n",
    "    test02(100);\n",
    "\n",
    "    //无参有返函数调用\n",
    "    int num1 = test03();\n",
    "    cout << \"num1 = \" << num1 << endl;\n",
    "\n",
    "    //有参有返函数调用\n",
    "    int num2 = test04(10000);\n",
    "    cout << \"num2 = \" << num2 << endl;\n",
    "\n",
    "    system(\"pause\");   //按任意键继续\n",
    "\n",
    "    return 0;\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "运行结果：  \n",
    " - this is test01  \n",
    " - this is test 02 a = 100  \n",
    " - this is test 03  \n",
    " - num1 = 1000  \n",
    " - this is test 04 a = 10000  \n",
    " - num2 = 10000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.6 函数声明"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "① 作用：告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义。\n",
    "\n",
    "② 函数的声明可以多次，但是函数的定义只能有一次。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <iostream>\n",
    "using namespace std;\n",
    "\n",
    "//函数的声明\n",
    "//比较函数，实现两个整型数字进行比较，返回较大的值。\n",
    "\n",
    "//提前告诉编译器函数的存在，可以利用函数的声明\n",
    "//函数的声明\n",
    "//声明可以写多次，但是定义只能有一次\n",
    "int max(int a, int b);\n",
    "int max(int a, int b);\n",
    "int max(int a, int b);\n",
    "\n",
    "int main()\n",
    "{\n",
    "    int a = 10;\n",
    "    int b = 20;\n",
    "    cout << max(a, b) << endl;\n",
    "\n",
    "    system(\"pause\");   //按任意键继续\n",
    "\n",
    "    return 0;\n",
    "\n",
    "}\n",
    "\n",
    "//函数定义在main函数之后，必须要在main函数之前写函数的声明\n",
    "int max(int a, int b)\n",
    "{\n",
    "    return a > b ? a : b;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "运行结果：  \n",
    " - 20"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.7 函数分文件编写"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "① 作用：让代码结构更加清晰。\n",
    "\n",
    "② 函数分文件编写一般有4个步骤：\n",
    "\n",
    "1. 创建后缀名为.h的头文件。\n",
    "2. 创建后缀名为.cpp的源文件。\n",
    "3. 在头文件中写函数的声明。\n",
    "4. 在源文件中写函数的定义。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.7.1 swap.h头文件"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "//这个是swap.h头文件\n",
    "\n",
    "#include <iostream>\n",
    "using namespace std;\n",
    "\n",
    "//函数的声明\n",
    "void swap(int a, int b);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.7.2 swap.pp源文件"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "//这个是swap.pp源文件\n",
    "\n",
    "#include \"swap.h\"\n",
    "\n",
    "//函数的定义\n",
    "void swap(int a, int b)\n",
    "{\n",
    "    int temp = a;\n",
    "    a = b;\n",
    "    b = temp;\n",
    "\n",
    "    cout << \"a = \" << a << endl;\n",
    "    cout << \"b = \" << b << endl;\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.7.3 主文件 .cpp文件"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "//主文件，调用函数分文件\n",
    "\n",
    "#include <iostream>\n",
    "using namespace std;\n",
    "#include \"swap.h\"  //包含要调用的函数的头文件，双引号表示我们自己写的头文件\n",
    "\n",
    "int main()\n",
    "{\n",
    "    int a = 10;\n",
    "    int b = 20;\n",
    "    cout << max(a, b) << endl;\n",
    "    \n",
    "    system(\"pause\");   //按任意键继续\n",
    "\n",
    "    return 0;\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.8 函数默认参数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "① 在C++中，函数的形参列表中的形参是可以有默认值的。\n",
    "\n",
    "② 语法：返回值类型 函数名 (参数 = 默认值) {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <iostream>\n",
    "using namespace std;\n",
    "\n",
    "//函数默认参数\n",
    "\n",
    "//如果我们自己传入数据，就用自己的数据，如果没有，那么永默认值\n",
    "//语法：返回值类型 函数名（形参 = 默认值）\n",
    "int func01(int a,int b,int c)\n",
    "{\n",
    "    return a + b + c;\n",
    "}\n",
    "//注意事项\n",
    "//1、如果某个位置以及有了默认参数，那么从这个位置往后，从左到右都必须有默认值\n",
    "int func02(int a, int b = 40, int c = 50)\n",
    "{\n",
    "    return a + b + c;\n",
    "}\n",
    "\n",
    "//2、如果函数声明有默认参数，函数实现就不能有默认参数\n",
    "//例如，函数定义为 int func03(int a = 20, int b = 20){return a + b;}，而函数声明为int func03(int a = 10, int b = 10);那么编译器不知道按照哪个默认参数来运行                                 \n",
    "//声明和实现只能有一个有默认参数\n",
    "int func03(int a = 10, int b = 10);\n",
    "\n",
    "//这个是函数的实现\n",
    "int func03(int a , int b) \n",
    "{  \n",
    "    return a + b;\n",
    "}\n",
    "\n",
    "int main()\n",
    "{\n",
    "    cout << func01(10, 20, 30) << endl;\n",
    "    cout << func02(10) << endl;\n",
    "    cout << func02(10, 20) << endl;\n",
    "    cout << func02(10, 20,30) << endl;\n",
    "\n",
    "    cout << func03() << endl;\n",
    "\n",
    "    system(\"pause\");\n",
    "\n",
    "    return 0;\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "运行结果：  \n",
    " - 60  \n",
    " - 100  \n",
    " - 80  \n",
    " - 60  \n",
    " - 20  \n",
    " - 请按任意键继续. . ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.9 函数占位参数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "① C++中函数的形参列表里可以有占位参数，用来做占位，调用函数时必须填补该位置。\n",
    "\n",
    "② 语法：返回值类型 函数名 （数据类型） {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <iostream>\n",
    "using namespace std;\n",
    "\n",
    "//占位参数\n",
    "//返回值类型 函数名(数据类型){}\n",
    "\n",
    "//目前，占位参数还用不到，后面会用到\n",
    "void func01(int a,int)\n",
    "{\n",
    "    cout << \"this is func01\" << endl;  //函数内部无法调用第二个参数，无法像a+b这样调用第二个参数                  \n",
    "}\n",
    "\n",
    "//占位参数，还可以有默认参数\n",
    "void func02(int a, int = 10)\n",
    "{\n",
    "    cout << \"this is func02\" << endl;  \n",
    "}\n",
    "\n",
    "int main()\n",
    "{\n",
    "    \n",
    "    func01(10, 20);\n",
    "    func02(10);  //有默认参数，可以只输入一个参数\n",
    "\n",
    "    system(\"pause\");\n",
    "\n",
    "    return 0;\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "运行结果：  \n",
    " - this is func01  \n",
    " - this is func02  \n",
    " - 请按任意键继续. . ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. 函数重载"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1 函数重载条件"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "① 作用：函数名可以相同，提高复用性。\n",
    "\n",
    "② 函数重载满足条件：\n",
    "\n",
    "1. 同一个作用域下。\n",
    "2. 函数名称相同。\n",
    "3. 函数参数类型不同 或者 个数不同 或者 顺序不同。\n",
    "\n",
    "③ 函数的返回值不可以作为函数重载的条件。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <iostream>\n",
    "using namespace std;\n",
    "\n",
    "//函数重载\n",
    "//可以让函数名相同，提高复用性\n",
    "\n",
    "//函数重载的满足条件\n",
    "//1、同一作用域下\n",
    "//2、函数名称相同\n",
    "//3、函数参数类型不同，或者个数不同，或者顺序不同\n",
    "void func()\n",
    "{\n",
    "    cout << \"func 的调用\" << endl;\n",
    "}\n",
    "\n",
    "void func(int a)\n",
    "{\n",
    "    cout << \"func (int a) 的调用\" << endl;\n",
    "}\n",
    "\n",
    "void func(double a)\n",
    "{\n",
    "    cout << \"func (double a) 的调用\" << endl;\n",
    "}\n",
    "\n",
    "void func(double a, int b)\n",
    "{\n",
    "    cout << \"func (double a, int b) 的调用\" << endl;\n",
    "}\n",
    "\n",
    "void func(int a, double b)\n",
    "{\n",
    "    cout << \"func (int a, double b) 的调用\" << endl;\n",
    "}\n",
    "\n",
    "/*\n",
    "注意事项\n",
    "函数的返回值不可以作为函数重载的条件\n",
    "int func(int a, double b)   \n",
    "//调用func(3.14,3)时，编译器不知道是调用int func(int a, double b){}还是调用void func(int a, double b){}                       \n",
    "{\n",
    "    cout << \"func (int a, double b) 的调用\" << endl;\n",
    "}\n",
    "*/\n",
    "\n",
    "int main()\n",
    "{\n",
    "    \n",
    "    func();  // 根据传入参数的个数不同，调用不同的函数\n",
    "    func(10);\n",
    "\n",
    "    func(3.14); // 根据传入参数的类型不同，调用不同的函数\n",
    "\n",
    "    func(3,3.14); // 根据传入参数的顺序不同，调用不同的函数\n",
    "    func(3.14,3); // 根据传入参数的顺序不同，调用不同的函数\n",
    "    system(\"pause\");\n",
    "\n",
    "    return 0;\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "运行结果：  \n",
    " - func 的调用  \n",
    " - func (int a) 的调用  \n",
    " - func (double a) 的调用  \n",
    " - func (int a, double b) 的调用  \n",
    " - func (double a, int b) 的调用  \n",
    " - 请按任意键继续. . ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 函数重载注意事项"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "① 引用作为重载条件。\n",
    "\n",
    "② 函数重载碰到函数默认参数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <iostream>\n",
    "using namespace std;\n",
    "\n",
    "//函数重载的注意事项\n",
    "//1、引用作为重载的条件\n",
    "void fun(int& a)   // int &a = 10; 不合法，所以fun(10);无法调用\n",
    "{\n",
    "    cout << \"func(int &a)调用\" << endl;\n",
    "}\n",
    "                        // const int &a = 10; 合法\n",
    "void fun(const int& a)  //语法是可以的，const引用和普通引用属于类型不同，fun(10)可以调用                                             \n",
    "{\n",
    "    cout << \"func(const int &a)调用\" << endl;\n",
    "}\n",
    "\n",
    "//2、函数重载碰到默认参数\n",
    "void func2(int a,int b = 20)\n",
    "{\n",
    "    cout << \"func2(int a,int b = 20) 的调用\" << endl;\n",
    "}\n",
    "\n",
    "void func2(int a)\n",
    "{\n",
    "    cout << \"func2(int a) 的调用\" << endl;\n",
    "}\n",
    "\n",
    "int main()\n",
    "{\n",
    "    int a = 10;  \n",
    "    //变量可读可写，所以调用变量时，是调用可读可写的引用函数，const int a = 10的fun(a);调用func(const int &a)调用                           \n",
    "    fun(a);\n",
    "    fun(10);\n",
    "               //既可以调用void func2(int a,int b = 20)，也可以调用void func2(int a)\n",
    "    //func2(10); //当函数重载碰到默认参数，出现二义性，报错，尽量避免这种情况\n",
    "\n",
    "    func2(10,20);  //不会出现二义性\n",
    "\n",
    "    system(\"pause\");\n",
    "\n",
    "    return 0;\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "运行结果：  \n",
    " - func(int &a)调用  \n",
    " - func(const int &a)调用  \n",
    " - func2(int a,int b = 20) 的调用  \n",
    " - 请按任意键继续. . ."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.6.3",
   "language": "python",
   "name": "python3.6.3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
